#include"../server.hpp"

// void HangupHandler(Channel* channel)
// {
//     std::cout<<"close:"<<channel->GetFd()<<std::endl;
//     //从epoller的红黑树中移除对该channel的监管
//     channel->Remove_Socket();
//     //删除该fd对应的channel
//     delete channel;
// }
// void RandomHandler(Channel* channel,EventLoop* eventloop)
// {
//     eventloop->DelayTaskInOneLoop(888);
// }
// void ReadHandler(Channel* channel)
// {
//     //1.读取客户端发来的数据
//     char buffer[1024];
//     int ret=read(channel->GetFd(),buffer,sizeof(buffer));
//     if(ret<0){
//         if(errno==EAGAIN || errno==EINTR)return;

//         Log(Error,"server read fail...");
//         //关闭该连接,
//         HangupHandler(channel);
//         return;
//     }
//     else if(ret==0){
//         Log(Info,"client exit,i will exit too!");
//         //关闭该连接,
//         HangupHandler(channel);
//         return;
//     }
//     //2.对数据做处理
//     std::cout<<"read:"<<buffer<<std::endl;
//     //3.反馈给客户端，即启动“写事件”监控
//     channel->Monitor_Write_Event();
// }

// void WriteHandler(Channel* channel)
// {
//     //服务器给客户端反馈响应
//     std::string echo_res="我是服务器，这是我给你的反馈.";
//     send(channel->GetFd(),echo_res.c_str(),echo_res.size(),0);
//     std::cout<<"write:"<<echo_res<<std::endl;
//     //写完数据后，需要关闭epoler对“写事件”的监管
//     channel->Close_Write_Event();
// }

// void ErrorHandler(Channel* channel){}

// void Acceptor(Channel* lst_channel,EventLoop* eventloop)
// {
//     //1.接收连接    
//     int new_fd=accept(lst_channel->GetFd(),nullptr,nullptr);
//     //2.为新fd创建channel对象
//     Channel* com_channel=new Channel(new_fd,eventloop);
//     //3.为com_channel填充回调函数
//     com_channel->SetReadHandler(std::bind(ReadHandler,com_channel));
//     com_channel->SetWriteHandler(std::bind(WriteHandler,com_channel));
//     com_channel->SetErrorHandler(std::bind(ErrorHandler,com_channel));
//     com_channel->SetHangupHandler(std::bind(HangupHandler,com_channel));
//     com_channel->SetRandomHandler(std::bind(RandomHandler,com_channel,eventloop));
//     //4.开启超时断开机制
//     eventloop->AddTimerTask(888,10,1,std::bind(HangupHandler,com_channel));
//     //5.将com_channel的“读事件”放入epoller的监管红黑树中
//     com_channel->Monitor_Read_Event();
// }

// int main()
// {
//     EventLoop eventloop;//管理所有的fd，包括lst_fd、com_fd
//     Socket lst_sock;
//     //1.创建监听套接字
//     lst_sock.CreateOneServer(8888);
//     //2.为监听套接字创建一个channel对象，用于管理lst_sock、处理lst_sock的各种事件
//     Channel lst_channel(lst_sock.GetFd(),&eventloop);
//     //3.设置lst_channel的read回调函数:1.接收连接  2.为新fd创建channel对象  3.为新channel填充回调函数
//     lst_channel.SetReadHandler(std::bind(Acceptor,&lst_channel,&eventloop));
//     //4.把listen_fd的“读事件”放入epoller的监管红黑树中，如果有新的连接到来，就会触发epoll_wait
//     lst_channel.Monitor_Read_Event();
//     //5.启动epoller的监管功能
//     while(1){
//         eventloop.Start();
//         std::cout<<"--------------------------"<<std::endl;
//         sleep(1);
//     }

//     // std::string client_ip;
//     // uint16_t client_port;
//     // int client_fd=lst_sock.Accept(client_ip,client_port);

//     // char arr[1024];
//     // lst_sock.Read(client_fd,arr,sizeof(arr));

//     // std::string echo_result="i have received a news...";
//     // echo_result+=arr;
//     // lst_sock.Write(client_fd,echo_result.c_str(),echo_result.size());

//     //关闭监听套接字
//     lst_sock.Close();

//     return 0;
// }

void HangupHandler(const PtrConnection& com_conn)
{
    std::cout<<"close:"<<com_conn->GetFd()<<std::endl;
    //从epoller的红黑树中移除对该channel的监管
    com_conn->Close();
}

void MessegeHandler(const PtrConnection& com_conn,Buffer* buffer)
{
    //1.对数据做处理
    std::cout<<std::this_thread::get_id()<<" server recv:"<<buffer->GetReadPosition()<<std::endl;
    buffer->MoveReadPosition(buffer->EnableReadSize());
    //2.反馈给客户端，即启动“写事件”监控
    std::string echo_back="你好，我是服务器，我收到了你的消息";
    std::cout<<"server echo back:"<<echo_back<<std::endl;
    com_conn->Send(echo_back.c_str(),echo_back.size());
}

void ErrorHandler(Channel* channel){}

void New_Connection_Established(const PtrConnection& conn){
    std::cout<<"新链接建立成功...fd:"<<conn->GetFd()<<std::endl;
};

std::unordered_map<int,PtrConnection> _conns;

// void Acceptor(Channel* lst_channel,EventLoop* eventloop)
// {
//     //1.接收连接    
//     int new_fd=accept(lst_channel->GetFd(),nullptr,nullptr);
//     //2.为新fd创建PtrConnection对象
//     PtrConnection com_conn(new Connection(conn_id,eventloop,new_fd));
//     //3.为com_conn填充回调函数
//     com_conn->SetMessegeReceivedCalback(std::bind(MessegeHandler,std::placeholders::_1,std::placeholders::_2));
//     com_conn->SetConnEstablishedCalback(std::bind(New_Connection_Established,std::placeholders::_1));
//     com_conn->SetSerCloseCalback(std::bind(Remove,9889));
//     //4.开启超时断开机制
//     com_conn->EnableInactiveRelease(3);
//     //5.连接建立成功、开启事件监控
//     com_conn->EnableEventMonitor();
//     //6.将新连接放到“用于管理所有链接的数据结构”中
//     _conns[conn_id]=com_conn;

//     conn_id++;
// }

// int main()
// {
//     EventLoop eventloop;//用于监控所有的fd，包括lst_fd、com_fd
//     Socket lst_sock;
//     //1.创建监听套接字
//     lst_sock.CreateOneServer(8888);
//     //2.为监听套接字创建一个channel对象，用于管理lst_sock、处理lst_sock的各种事件
//     Channel lst_channel(lst_sock.GetFd(),&eventloop);
//     //3.设置lst_channel的read回调函数:1.接收连接  2.为新fd创建channel对象  3.为新channel填充回调函数
//     lst_channel.SetReadHandler(std::bind(Acceptor,&lst_channel,&eventloop));
//     //4.把listen_fd的“读事件”放入epoller的监管红黑树中，如果有新的连接到来，就会触发epoll_wait
//     lst_channel.Monitor_Read_Event();
//     //5.启动epoller的监管功能
//     while(1){
//         eventloop.Start();//阻塞式监控lst套接字————>收到新连接————>为新连接创建Connection对象，监控com和lst套接字
//         std::cout<<"--------------------------"<<std::endl;
//         //sleep(1);
//     }

//     //关闭监听套接字
//     lst_sock.Close();

//     return 0;
// }

int main()
{
    TcpServer tcpser(8888,2);
    tcpser.SetConnEstablishedCalback(std::bind(New_Connection_Established,std::placeholders::_1));
    tcpser.SetMessegeReceivedCalback(std::bind(MessegeHandler,std::placeholders::_1,std::placeholders::_2));
    tcpser.Start();
    return 0;
}